home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 1 / PC World Interactive 1 - Nisan 1997.iso / prog / graf / 5 / _001730_ < prev    next >
Encoding:
Text File  |  1996-06-04  |  15.0 KB  |  415 lines
  1. //------------------------------------------------------------------------------------------------------
  2. // Name       : import_.c
  3. // Date       : 23.05.1996     Author : SM           System : Win32
  4. //------------------------------------------------------------------------------------------------------
  5. // This file contains the language-independent implementation of the module IMPORT_.DLL. All texts and
  6. // resources that are language-dependent are located in an additional IMPORT.DLL, whose sources can be
  7. // found in the subdirectories \E (for English) and \D (for German).
  8. //------------------------------------------------------------------------------------------------------
  9.  
  10. #define USER_DATA_ID          "1.00-1995-08-10"
  11.  
  12. //------------------------------------------------------------------------------------------------------
  13.  
  14. #include        "windows.h"
  15. #include        "windowsx.h"
  16. #include        "stdlib.h"
  17. #include        "stdio.h"
  18. #include        "math.h"
  19.  
  20. #include        "e:\release4\toso40.h"          // Toso Interface 4.0 Definitions
  21. #include        "dialog.h"
  22.  
  23. //------------------------------------------------------------------------------------------------------
  24.  
  25. typedef struct {
  26.   STR32         TimeStamp;
  27.  
  28.   FILENAME      FileName;
  29. } INF_HEADER;
  30.  
  31. //------ Language-dependent texts in IMPORT.DLL --------------------------------------------------------
  32.  
  33. DLL_IMPORT LPSTR
  34.         eStartUpText    [],
  35.         eDefaultName    [],
  36.         eDialogText     [],
  37.         eMessageText    [];
  38.  
  39. //------------------------------------------------------------------------------------------------------
  40.  
  41. static  HINSTANCE       hInstDLL,               // Instance handle of the main DLL
  42.                         hLanguage,              // Instance handle of the language DLL
  43.                         hGlobalInst;            // Instance handle of the serving application
  44. static  HWND            hGlobalWnd;             // Main window handle of the serving application
  45.  
  46. //------------------------------------------------------------------------------------------------------
  47.  
  48. static  HBITMAP         hBitmap;
  49. static  INF_HEADER      INFHeader;
  50. static  int             gError;                 // Current error status ( 0 = OK )
  51.  
  52. //------------------------------------------------------------------------------------------------------
  53.  
  54. BOOL ModuleLoadSettings( void )
  55. {
  56.   BOOL          Result = FALSE;
  57.  
  58.   if( TosoProfileReadKeyOpen( "IMPORT", FALSE ) ) {
  59.     if( TosoProfileReadData( "Init", (LPBYTE) &INFHeader, sizeof( INFHeader ) ) )
  60.       Result = TRUE;
  61.     TosoProfileReadKeyClose();
  62.  
  63.     INFHeader.TimeStamp[31] = 0x00;
  64.     if( lstrcmp( INFHeader.TimeStamp, USER_DATA_ID ) )
  65.       Result = FALSE;
  66.   }
  67.  
  68.   if( !Result ) {
  69.     lstrcpy( INFHeader.FileName, eDefaultName[0] );
  70.   }
  71.   return( Result );
  72. }
  73.  
  74. //------------------------------------------------------------------------------------------------------
  75.  
  76. BOOL ModuleSaveSettings( void )
  77. {
  78.   BOOL          Result = FALSE;
  79.  
  80.   if( TosoProfileWriteKeyOpen( "IMPORT", FALSE ) ) {
  81.     lstrcpy( INFHeader.TimeStamp, USER_DATA_ID );
  82.     if( TosoProfileWriteData( "Init", (LPBYTE) &INFHeader, sizeof( INFHeader ) ) )
  83.       Result = TRUE;
  84.     TosoProfileWriteKeyClose();
  85.   }
  86.   return( Result );
  87. }
  88.  
  89. //------------------------------------------------------------------------------------------------------
  90. // This procedure reads a single coordinate pair from the current file. If it finds the last line of the
  91. // file (indicated by the DB_END data block identifier), it returns FALSE without setting gError to a
  92. // non-zero value.
  93.  
  94. BOOL ModuleReadCoordinate( double* x, double* y )
  95. {
  96.   DUMMYSTR      Text1, Text2;
  97.   short         Dummy;
  98.  
  99.   if( gError )
  100.     return( FALSE );
  101.  
  102.   wsprintf( Text1, eDialogText[3], TosoFileReadCurrentLine() );
  103.   wsprintf( Text2, eDialogText[4], ( TosoFileReadCurrentSize() + 1023 ) / 1024 );
  104.   TosoDialogUpdateProgress( Text1, Text2, TosoFileReadCurrentSize(), TosoFileReadTotalSize() );
  105.  
  106.   if( TosoDialogIsCanceled() ) {
  107.     gError = 999;
  108.     return( FALSE );
  109.   }
  110.  
  111.   TosoFileReadShort( &Dummy );
  112.   if( Dummy == DB_END )
  113.     return( FALSE );
  114.  
  115.   TosoFileReadCommaDouble( x );
  116.   TosoFileReadCommaDouble( y );
  117.   TosoFileReadSemi();
  118.  
  119.   if( TosoFileReadError() ) {
  120.     gError = 2;
  121.     return( FALSE );
  122.   }
  123.  
  124.   return( TRUE );
  125. }
  126.  
  127. //------------------------------------------------------------------------------------------------------
  128. // This procedure performs the import. It reads all coordinate pairs from the import file and insert a
  129. // marking for each coordinate pair.
  130. // In addition, it initializes and display a progress indicator window to inform the user about the
  131. // current progress and to allow him to cancel the import. Since the final file size is already known
  132. // in advance, the progress indicator does include a percent bar.
  133.  
  134. void ModuleImport( HANDLE FileHandle, const LPSTR FileName )
  135. {
  136.   FILENAME      FileName2;
  137.   DUMMYSTR      DummyStr;
  138.   int           Count;
  139.   double        x, y;
  140.  
  141.   gError = 0;
  142.  
  143.   if( !TosoFileReadInitDisk( FileHandle ) )
  144.     return;
  145.  
  146.   TosoFileSplitName( FileName, NULL, FileName2 );
  147.   wsprintf( DummyStr, eDialogText[2], FileName2 );
  148.   TosoDialogShowProgress( eDialogText[0], DummyStr, TRUE );
  149.  
  150.   if( ModuleReadCoordinate( &x, &y ) ) {
  151.     Count = 0;
  152.  
  153.     do {
  154.       if( Count == 0 )
  155.         TosoObjectOpen( OBJ_MARK );
  156.  
  157.       TosoObjectAddPoint( DB_POINT_MARK, x, y );
  158.       Count++;
  159.  
  160.       if( Count >= POINTS_PER_OBJECT ) {
  161.         if( !TosoObjectFastInsert() ) {
  162.           gError = 998;
  163.           goto _stop;
  164.         }
  165.         Count = 0;
  166.       }
  167.     } while( ModuleReadCoordinate( &x, &y ) );
  168.  
  169.     if( Count > 0 )
  170.       if( !TosoObjectFastInsert() )
  171.         gError = 998;
  172.  
  173.     TosoFileReadSemi();
  174.   }
  175.  
  176. _stop:
  177.   TosoFileReadExit();
  178.   TosoDialogHideProgress();
  179. }
  180.  
  181. //------------------------------------------------------------------------------------------------------
  182. // This DLL entry procedure must exist in any DLL to be used in Win32. Since our DLL does all necessary
  183. // initialization in its TosoModuleInit() procedure, this procedure is quite empty.
  184.  
  185. BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD Reason, LPVOID Dummy )
  186. {
  187.   switch( Reason ) {
  188.     case DLL_PROCESS_ATTACH:
  189.       hInstDLL = hInstance;
  190.       break;
  191.  
  192.     case DLL_PROCESS_DETACH:
  193.       hInstDLL = NULL;
  194.       break;
  195.   }
  196.   return( TRUE );
  197. }
  198.  
  199. //------------------------------------------------------------------------------------------------------
  200. // This procedure is called when the module is loaded by the serving application. Its main tasks are:
  201. // - Checking whether it is compatible with the given InterfaceVersion
  202. // - Checking whether it is licensed to the given serial number (optional)
  203. // - Storing of the serving application's instance and main windows handle for further use
  204. // - Loading of the language-dependent library
  205. // - Filling in the module ID structure whose address is passed in ModuleID
  206. // - Loading of options from the registry database
  207. // - Loading profiles
  208. // - Allocating any static memory required
  209.  
  210. DLL_EXPORT BOOL TosoModuleInit( const LPSTR SerialNumber, HINSTANCE hMainInst, HWND hMainWnd,
  211.                                                           int InterfaceVersion, MODULE_ID* ModuleID )
  212. {
  213.   if( InterfaceVersion < TOSO_INTERFACE_VERSION ) {
  214.     MessageBox( hMainWnd, eMessageText[0], eDialogText[0], MB_OK );
  215.     return( FALSE );
  216.   }
  217.   hGlobalInst = hMainInst;
  218.   hGlobalWnd  = hMainWnd;
  219.  
  220.   hLanguage = LoadLibrary( "IMPORT.DLL" );
  221.   hBitmap = LoadBitmap( hLanguage, "IDB_COMMAND" );
  222.  
  223.   ModuleID->OwnerID    = DB_OWNER_TOSO;
  224.   ModuleID->ModuleID   = 0x1000;
  225.   ModuleID->ModuleCTRL = MODULECTRL_ALL;
  226.  
  227.   ModuleID->ModuleProc.InputPointInitProc = (TOSOINPUTPOINTINIT_PROC) NULL;
  228.   ModuleID->ModuleProc.InputPointMoveProc = (TOSOINPUTPOINTMOVE_PROC) NULL;
  229.   ModuleID->ModuleProc.InputPointExitProc = (TOSOINPUTPOINTEXIT_PROC) NULL;
  230.   ModuleID->ModuleProc.InputDisplayProc   = (TOSOINPUTDISPLAY_PROC)   NULL;
  231.   ModuleID->ModuleProc.InputParameterProc = (TOSOINPUTPARAMETER_PROC) NULL;
  232.   ModuleID->ModuleProc.InputCancelProc    = (TOSOINPUTCANCEL_PROC)    NULL;
  233.   ModuleID->ModuleProc.InputFinishProc    = (TOSOINPUTFINISH_PROC)    NULL;
  234.  
  235.   ModuleID->ModuleData.Type = MODULETYPE_IMPORT;
  236.  
  237.   ModuleID->ModuleData.InputData.CommandMode = COMMAND_DIRECT;
  238.   ModuleID->ModuleData.MenuData.MenuEntry   = eStartUpText[1];
  239.   ModuleID->ModuleData.MenuData.Description = eStartUpText[2];
  240.  
  241.   ModuleID->ModuleData.IconHandle  = hBitmap;
  242.   ModuleID->ModuleData.IconXOffset = 0;
  243.   ModuleID->ModuleData.IconYOffset = 0;
  244.   ModuleID->ModuleData.IconMode    = 0;
  245.  
  246.   ModuleID->CommandData = NULL;
  247.  
  248.   ModuleLoadSettings();
  249.  
  250.   return( TRUE );
  251. }
  252.  
  253. //------------------------------------------------------------------------------------------------------
  254. // This procedure is called when the module is removed by the serving application. Its main tasks are:
  255. // - Checking whether anything is to be saved. If so, it should display a message information the user
  256. //   about it and allowing him to save those changes.
  257. // - Freeing of all statically allocated memory.
  258. // If this procedure return FALSE, the serving application will not be able to terminate. So please, do
  259. // only return FALSE if shutting down the module now would severely damage or destroy user data.
  260.  
  261. DLL_EXPORT BOOL TosoModuleExit( void )
  262. {
  263.   ModuleSaveSettings();
  264.  
  265.   DeleteBitmap( hBitmap );
  266.  
  267.   return( TRUE );
  268. }
  269.  
  270. //------------------------------------------------------------------------------------------------------
  271. // This procedure serves as hook procedure for the comman file open dialog window. It manages the Infos
  272. // button that has been added to the standard GetOpenFileName dialog template.
  273. // In a more sophisticated import module, the common dialog would also contain a Options button which
  274. // would also be managed in this procedure.
  275.  
  276. UINT CALLBACK TosoModuleGetFileNameHook( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam )
  277. {
  278.   switch( message ) {
  279.     case WM_INITDIALOG:                                 // Initialize dialog box
  280.       TosoDialogCenter( hDlg );                         // Center dialog window
  281.       return( 1 );
  282.  
  283.     case WM_COMMAND:
  284.       switch( GET_WM_COMMAND_ID( wParam, lParam ) ) {
  285.         case IDD_BUTTON0:                               // Infos
  286.           MessageBox( hDlg, eStartUpText[0], eDialogText[0], MB_OK );
  287.           return( 1 );
  288.       }
  289.       break;
  290.  
  291.     case WM_ENTERIDLE:
  292.       return( TosoDialogEnterIdle( hDlg, wParam, lParam ) );
  293.  
  294.     default:
  295.       if( message == TosoDialogHelpMessage() ) {
  296.         WinHelp( hDlg, "IMPORT.HLP", HELP_CONTEXT, 1 );
  297.         return( 1 );
  298.       }
  299.       break;
  300.   }
  301.   return( 0 );                                          // Didn't process a message
  302. }
  303.  
  304. //------------------------------------------------------------------------------------------------------
  305. // This procedure is called when a module's command is chosen by the user. For an import filter, its
  306. // main tasks are:
  307. // - Prompting the user for the file name of the import file. This should usually be done by means of
  308. //   common dialog windows extended by some additional buttons like Infos and Options
  309. // - Opening the import file
  310. // - Calling the basic import procedure
  311. // - Closing the import file
  312. // - Error handling and display
  313.  
  314. DLL_EXPORT BOOL TosoModuleCommand( int CommandID, int ExecMode )
  315. {
  316.   static  OPENFILENAME  OpenData;
  317.   static  FILENAME      FileName;
  318.   HANDLE                FileHandle;
  319.   DUMMYSTR              DummyStr;
  320.   DWORD                 CmnDlgError;
  321.   BOOL                  Result = FALSE;
  322.  
  323.   if( CommandID != 0 )
  324.     return( FALSE );
  325.  
  326. // Check whether a help topic is to be displayed instead of starting a command.
  327.  
  328.   if( ExecMode == MODULEEXEC_HELP ) {
  329.     WinHelp( hGlobalWnd, "IMPORT.HLP", HELP_CONTEXT, 1 );
  330.     return( FALSE );
  331.   }
  332.  
  333.   if( !TosoCreationStart() )
  334.     return( FALSE );
  335.  
  336.   lstrcpy( FileName, INFHeader.FileName );
  337.  
  338.   OpenData.lStructSize       = sizeof( OPENFILENAME );
  339.   OpenData.hwndOwner         = hGlobalWnd;
  340.   OpenData.hInstance         = hLanguage;
  341.   OpenData.lpstrFilter       = eDialogText[1];
  342.   OpenData.lpstrCustomFilter = NULL;
  343.   OpenData.nMaxCustFilter    = 0;
  344.   OpenData.nFilterIndex      = 1;
  345.   OpenData.lpstrFile         = FileName;
  346.   OpenData.nMaxFile          = sizeof( FileName );
  347.   OpenData.lpstrFileTitle    = NULL;
  348.   OpenData.nMaxFileTitle     = 0;
  349.   OpenData.lpstrInitialDir   = NULL;
  350.   OpenData.lpstrTitle        = eDialogText[0];
  351.   OpenData.Flags             = OFN_HIDEREADONLY | OFN_NONETWORKBUTTON | OFN_SHOWHELP |
  352.                                OFN_ENABLEHOOK | OFN_ENABLETEMPLATE | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
  353.   OpenData.nFileOffset       = 0;
  354.   OpenData.nFileExtension    = 0;
  355.   OpenData.lpstrDefExt       = eDefaultName[2];
  356.   OpenData.lCustData         = NOPARAM;
  357.   OpenData.lpfnHook          = (LPOFNHOOKPROC) TosoModuleGetFileNameHook;
  358.   OpenData.lpTemplateName    = "GETFILENAME";
  359.  
  360.   Result = GetOpenFileName( &OpenData );                // Open common dialog window     
  361.                                                                                          
  362.   if( !Result )                                         // TRUE=OK, FALSE=cancel or error
  363.     CmnDlgError = CommDlgExtendedError();               // 0=cancel, else error number   
  364.                                                                                          
  365.   if( !Result ) {                                       // Cancel                        
  366.     if( CmnDlgError ) {                                 // Error in common dialog        
  367.       wsprintf( DummyStr, eMessageText[3], CmnDlgError );
  368.       MessageBox( hGlobalWnd, DummyStr, eDialogText[0], MB_OK );
  369.     }
  370.     return( TRUE );
  371.   }
  372.   else                                                  // Store the selected file name
  373.     lstrcpy( INFHeader.FileName, FileName );
  374.  
  375.   Result = FALSE;
  376.   SetCursor( LoadCursor( NULL, IDC_WAIT ) );
  377.  
  378.   if( TosoFileOpen( &FileHandle, FileName ) ) {
  379.     TosoUndoInitProcess();
  380.  
  381.     ModuleImport( FileHandle, FileName );
  382.  
  383.     TosoFileClose( FileHandle );
  384.     switch( gError ) {
  385.       case 999:
  386.         TosoUndoCancelProcess();
  387.         MessageBox( hGlobalWnd, eMessageText[2], eDialogText[0], MB_OK );
  388.         Result = TRUE;
  389.         break;
  390.  
  391.       case 998:
  392.         TosoUndoCancelProcess();
  393.         MessageBox( hGlobalWnd, eMessageText[4], eDialogText[0], MB_OK );
  394.         Result = FALSE;
  395.         break;
  396.  
  397.       case 0:
  398.         TosoUndoFinishProcess();
  399. //      TosoUndoUpdateLinks();       <- Would only be necessary if blocks or instances had been modified!
  400.         TosoDrawWindowAll();
  401.         Result = TRUE;
  402.         break;
  403.  
  404.       default:
  405.         TosoUndoCancelProcess();
  406.         wsprintf( DummyStr, eMessageText[5], gError, TosoFileReadCurrentLine(), TosoFileReadCurrentSize() );
  407.         MessageBox( hGlobalWnd, DummyStr, eDialogText[0], MB_OK );
  408.         Result = FALSE;
  409.         break;
  410.     }
  411.   }
  412.   TosoCreationEnd();
  413.   return( Result );
  414. }
  415.